<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" dir="ltr" class="client-nojs">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Member access operators - cppreference.com</title>
<meta charset="UTF-8">
<meta name="generator" content="MediaWiki 1.21.2">


<link rel="shortcut icon" href="../../../favicon.ico">



<link rel="stylesheet" href="../../../common/ext.css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" href="../../../common/site_modules.css">
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),a:lang(ur){text-decoration:none}#toc{display:none}.editsection{display:none}
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-css:7:472787eddcf4605d11de8c7ef047234f */</style>

<script src="../../../common/startup_scripts.js"></script>
<script>if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"cpp/language/operator_member_access","wgTitle":"cpp/language/operator member access","wgCurRevisionId":76806,"wgArticleId":707,"wgIsArticle":true,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":[],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"cpp/language/operator_member_access","wgRestrictionEdit":[],"wgRestrictionMove":[]});
}</script><script>if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"editfont":"default","editondblclick":0,"editsection":0,"editsectiononrightclick":0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatchlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig":0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imagesize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocache":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching":1,"showtoc":0,"showtoolbar":1,"skin":"cppreference2","stubthreshold":0,"thumbsize":2,"underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0,"watchdeletion":0,
"watchlistdays":3,"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthideminor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchNs2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":false,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"searchNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs15":false,"gadget-ColiruCompiler":1});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.tokens.set({"editToken":"+\\","patrolToken":false,"watchToken":false});;},{},{});
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-js:7:ca03345b1e2c4d90a25d968753a73b92 */
}</script>
<script>if(window.mw){
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.legacy.ajax"]);
}</script>
<style type="text/css">/*<![CDATA[*/
.source-cpp {line-height: normal;}
.source-cpp li, .source-cpp pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for cpp
 * CSS class: source-cpp, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.cpp.source-cpp .de1, .cpp.source-cpp .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.cpp.source-cpp  {font-family:monospace;}
.cpp.source-cpp .imp {font-weight: bold; color: red;}
.cpp.source-cpp li, .cpp.source-cpp .li1 {font-weight: normal; vertical-align:top;}
.cpp.source-cpp .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.cpp.source-cpp .li2 {font-weight: bold; vertical-align:top;}
.cpp.source-cpp .kw1 {color: #0000dd;}
.cpp.source-cpp .kw2 {color: #0000ff;}
.cpp.source-cpp .kw3 {color: #0000dd;}
.cpp.source-cpp .kw4 {color: #0000ff;}
.cpp.source-cpp .co1 {color: #909090;}
.cpp.source-cpp .co2 {color: #339900;}
.cpp.source-cpp .coMULTI {color: #ff0000; font-style: italic;}
.cpp.source-cpp .es0 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es1 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es2 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es3 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es4 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es5 {color: #008000; font-weight: bold;}
.cpp.source-cpp .br0 {color: #008000;}
.cpp.source-cpp .sy0 {color: #008000;}
.cpp.source-cpp .sy1 {color: #000080;}
.cpp.source-cpp .sy2 {color: #000040;}
.cpp.source-cpp .sy3 {color: #000040;}
.cpp.source-cpp .sy4 {color: #008080;}
.cpp.source-cpp .st0 {color: #008000;}
.cpp.source-cpp .nu0 {color: #000080;}
.cpp.source-cpp .nu6 {color: #000080;}
.cpp.source-cpp .nu8 {color: #000080;}
.cpp.source-cpp .nu12 {color: #000080;}
.cpp.source-cpp .nu16 {color:#000080;}
.cpp.source-cpp .nu17 {color:#000080;}
.cpp.source-cpp .nu18 {color:#000080;}
.cpp.source-cpp .nu19 {color:#000080;}
.cpp.source-cpp .ln-xtra, .cpp.source-cpp li.ln-xtra, .cpp.source-cpp div.ln-xtra {background-color: #ffc;}
.cpp.source-cpp span.xtra { display:block; }

/*]]>*/
</style>
<style type="text/css">/*<![CDATA[*/
.source-text {line-height: normal;}
.source-text li, .source-text pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for text
 * CSS class: source-text, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.text.source-text .de1, .text.source-text .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.text.source-text  {font-family:monospace;}
.text.source-text .imp {font-weight: bold; color: red;}
.text.source-text li, .text.source-text .li1 {font-weight: normal; vertical-align:top;}
.text.source-text .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.text.source-text .li2 {font-weight: bold; vertical-align:top;}
.text.source-text .ln-xtra, .text.source-text li.ln-xtra, .text.source-text div.ln-xtra {background-color: #ffc;}
.text.source-text span.xtra { display:block; }

/*]]>*/
</style>
<!--[if lt IE 7]><style type="text/css">body{behavior:url("/mwiki/skins/cppreference2/csshover.min.htc")}</style><![endif]-->
</head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-cpp_language_operator_member_access skin-cppreference2 action-view cpp-navbar">
        <!-- header -->
        
        <!-- /header -->
        <!-- content -->
        <div id="cpp-content-base">
            <div id="content">
                <a id="top"></a>
                <div id="mw-js-message" style="display:none;"></div>
                                <!-- firstHeading -->
                <h1 id="firstHeading" class="firstHeading">Member access operators</h1>
                <!-- /firstHeading -->
                <!-- bodyContent -->
                <div id="bodyContent">
                                        <!-- tagline -->
                    <div id="siteSub">From cppreference.com</div>
                    <!-- /tagline -->
                                        <!-- subtitle -->
                    <div id="contentSub"><span class="subpages">&lt; <a href="../../cpp.html" title="cpp">cpp</a>‎ | <a href="../language.1.html" title="cpp/language">language</a></span></div>
                    <!-- /subtitle -->
                                                            <!-- bodycontent -->
                    <div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr">
<div class="t-navbar" style="">
<div class="t-navbar-sep"> </div>
<div class="t-navbar-head">
<a href="../../cpp.html" title="cpp"> C++</a><div class="t-navbar-menu"><div>
<div><table class="t-nv-begin" cellpadding="0" style="line-height:1.1em;">
<tr class="t-nv"><td colspan="5"> <a href="../language.1.html" title="cpp/language"> Language</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../header.html" title="cpp/header"> Standard library headers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../concept.html" title="cpp/concept"> Concepts</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../utility.html" title="cpp/utility"> Utilities library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../string.html" title="cpp/string"> Strings library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../container.html" title="cpp/container"> Containers library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../algorithm.html" title="cpp/algorithm"> Algorithms library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../iterator.html" title="cpp/iterator"> Iterators library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../numeric.html" title="cpp/numeric"> Numerics library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../io.html" title="cpp/io"> Input/output library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../locale.html" title="cpp/locale"> Localizations library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../regex.html" title="cpp/regex"> Regular expressions library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../atomic.html" title="cpp/atomic"> Atomic operations library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../thread.html" title="cpp/thread"> Thread support library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="cpp/experimental"> Technical Specifications</a> </td></tr>
</table></div>
<div></div>
</div></div>
</div>
<div class="t-navbar-sep"> </div>
<div class="t-navbar-head"><a href="../language.1.html" title="cpp/language"> C++ language</a></div>
<div class="t-navbar-sep"> </div>
<div class="t-navbar-head">
<a href="expressions.html" title="cpp/language/expressions"> Expressions</a><div class="t-navbar-menu"><div>
<div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h2"><td colspan="5"> General </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="value_category.html" title="cpp/language/value category"> value categories</a> (lvalue, rvalue, xvalue)</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="eval_order.html" title="cpp/language/eval order"> order of evaluation</a> (sequence points)</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constant_expression.html" title="cpp/language/constant expression"> constant expressions</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html#Unevaluated_expressions" title="cpp/language/expressions"> unevaluated expressions</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html#Primary_expressions" title="cpp/language/expressions"> primary expressions</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="lambda.html" title="cpp/language/lambda">lambda-expression</a><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv-h2"><td colspan="5"> Literals </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="integer_literal.html" title="cpp/language/integer literal">integer literals</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="floating_literal.html" title="cpp/language/floating literal">floating-point literals</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="bool_literal.html" title="cpp/language/bool literal">boolean literals</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="character_literal.html" title="cpp/language/character literal">character literals</a> including <a href="escape.html" title="cpp/language/escape">escape sequences</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="string_literal.html" title="cpp/language/string literal">string literals</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="nullptr.html" title="cpp/language/nullptr">null pointer literal</a><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="user_literal.html" title="cpp/language/user literal">user-defined literal</a><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv-h2"><td colspan="5"> Operators </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_assignment.html" title="cpp/language/operator assignment"> Assignment operators</a>: 
<code>a=b</code>, <code>a+=b</code>, <code>a-=b</code>, <code>a*=b</code>, <code>a/=b</code>, <code>a%=b</code>, <code>a&amp;=b</code>, <code>a|=b</code>, <code>a^=b</code>, <code>a&lt;&lt;=b</code>, <code>a&gt;&gt;=</code>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_incdec.html" title="cpp/language/operator incdec"> Increment and decrement</a>: <code>++a</code>, <code>--a</code>, <code>a++</code>, <code>a--</code>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_arithmetic.html" title="cpp/language/operator arithmetic"> Arithmetic operators</a>:
<code>+a</code>, <code>-a</code>, <code>a+b</code>, <code>a-b</code>, <code>a*b</code>, <code>a/b</code>, <code>a%b</code>, <code>~a</code>, <code>a&amp;b</code>, <code>a|b</code>, <code>a^b</code>, <code>a&lt;&lt;b</code>, <code>a&gt;&gt;b</code> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_logical.html" title="cpp/language/operator logical"> Logical operators</a>: <code>a||b</code>, <code>a&amp;&amp;b</code>, <code>!a</code>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_comparison.html" title="cpp/language/operator comparison"> Comparison operators</a>: <code>a==b</code>, <code>a!=b</code>, <code>a&lt;b</code>, <code>a&gt;b</code>, <code>a&lt;=b</code>, <code>a&gt;=b</code>
</td></tr>
<tr class="t-nv"><td colspan="5"> <strong class="selflink"> Member access operators</strong>: <code>a[b]</code>, <code>*a</code>, <code>&amp;a</code>, <code>a-&gt;b</code>, <code>a.b</code>, <code>a-&gt;*b</code>, <code>a.*b</code>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_other.html" title="cpp/language/operator other"> Other operators</a>: <code>a(...)</code>, <code>a,b</code>, <code>(T)a</code>, <code>a?b:c</code> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_alternative.html" title="cpp/language/operator alternative">Alternative representations of operators</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_precedence.html" title="cpp/language/operator precedence">Precedence and associativity</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="fold.html" title="cpp/language/fold">Fold expression</a><span class="t-mark-rev t-since-cxx17">(C++17)</span>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="new.html" title="cpp/language/new">new-expression</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="delete.html" title="cpp/language/delete">delete-expression</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="throw.html" title="cpp/language/throw">throw-expression</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="alignof.html" title="cpp/language/alignof">alignof</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="sizeof.html" title="cpp/language/sizeof">sizeof</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="sizeof....html" title="cpp/language/sizeof...">sizeof...</a><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="typeid.html" title="cpp/language/typeid">typeid</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="noexcept.html" title="cpp/language/noexcept">noexcept</a><span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operators.html" title="cpp/language/operators">Operator overloading</a>
</td></tr>
<tr class="t-nv-h2"><td colspan="5"> Conversions </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="implicit_cast.html" title="cpp/language/implicit cast">Implicit conversions</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="const_cast.html" title="cpp/language/const cast">const_cast</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static_cast.html" title="cpp/language/static cast">static_cast</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="reinterpret_cast.html" title="cpp/language/reinterpret cast">reinterpret_cast</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="dynamic_cast.html" title="cpp/language/dynamic cast">dynamic_cast</a>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="explicit_cast.html" title="cpp/language/explicit cast">Explicit conversions</a> <code>(T)a</code>, <code>T(a)</code>
</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="cast_operator.html" title="cpp/language/cast operator">User-defined conversion</a>
</td></tr>
</table></div>
</div>
<div></div>
</div></div>
</div>
<div class="t-navbar-sep"> </div>
</div>
<p>Accesses a member of an object.
</p>
<table class="wikitable" style="font-size:85%;">

<tr>
<th rowspan="2"> Operator name
</th>
<th rowspan="2"> Syntax
</th>
<th rowspan="2"> <a href="operators.html" title="cpp/language/operators">Over​load​able</a>
</th>
<th colspan="2"> Prototype examples (for <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw1">class</span> T</span></span>)
</th>
</tr>
<tr>
<th> Inside class definition
</th>
<th> Outside class definition
</th>
</tr>
<tr>
<td> array subscript
</td>
<td> <code>a[b]</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="br0">[</span><span class="br0">]</span><span class="br0">(</span><span class="kw4">const</span> T2<span class="sy3">&amp;</span> b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
</tr>
<tr>
<td> indirection (variable pointed to by <code>a</code>)
</td>
<td> <code>*a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">*</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> operator<span class="sy2">*</span><span class="br0">(</span>T <span class="sy3">&amp;</span>a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
</tr>
<tr>
<td> address of
</td>
<td> <code>&amp;a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy3">&amp;</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> operator<span class="sy3">&amp;</span><span class="br0">(</span>T <span class="sy3">&amp;</span>a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
</tr>
<tr>
<td> member of object
</td>
<td> <code>a.b</code>
</td>
<td style="background:#ff9090; color:black; vertical-align: middle; text-align: center;" class="table-no"> No
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
</tr>
<tr>
<td> member of pointer
</td>
<td> <code>a-&gt;b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">-</span><span class="sy1">&gt;</span><span class="br0">(</span><span class="br0">)</span></span></span>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
</tr>
<tr>
<td> pointer to member of object
</td>
<td> <code>a.*b</code>
</td>
<td style="background:#ff9090; color:black; vertical-align: middle; text-align: center;" class="table-no"> No
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
</tr>
<tr>
<td> pointer to member of pointer
</td>
<td> <code>a-&gt;*b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span><span class="br0">(</span>R<span class="br0">)</span></span></span>
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> operator<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span><span class="br0">(</span>T, R<span class="br0">)</span></span></span>
</td>
</tr>
<tr>
<td colspan="5">
<dl><dd>
<b>Notes</b><br>
</dd></dl>
<ul><li> As with most user-defined overloads, return types should match return types provided by the builtin operators so that <a href="operators.html" title="cpp/language/operators">the user-defined operators</a> can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">void</span></span></span>). One exception is <code>operator-&gt;</code>, which must return a pointer or another class with overloaded <code>operator-&gt;</code>.
</li></ul>
</td>
</tr>
</table>
<table id="toc" class="toc"><tr><td>
<div id="toctitle"><h2>Contents</h2></div>
<ul>
<li class="toclevel-1 tocsection-1">
<a href="operator_member_access.html#Explanation"><span class="tocnumber">1</span> <span class="toctext">Explanation</span></a>
<ul>
<li class="toclevel-2 tocsection-2"><a href="operator_member_access.html#Built-in_subscript_operator"><span class="tocnumber">1.1</span> <span class="toctext">Built-in subscript operator</span></a></li>
<li class="toclevel-2 tocsection-3"><a href="operator_member_access.html#Built-in_indirection_operator"><span class="tocnumber">1.2</span> <span class="toctext">Built-in indirection operator</span></a></li>
<li class="toclevel-2 tocsection-4"><a href="operator_member_access.html#Built-in_address-of_operator"><span class="tocnumber">1.3</span> <span class="toctext">Built-in address-of operator</span></a></li>
<li class="toclevel-2 tocsection-5"><a href="operator_member_access.html#Built-in_member_access_operators"><span class="tocnumber">1.4</span> <span class="toctext">Built-in member access operators</span></a></li>
<li class="toclevel-2 tocsection-6"><a href="operator_member_access.html#Built-in_pointer-to-member_access_operators"><span class="tocnumber">1.5</span> <span class="toctext">Built-in pointer-to-member access operators</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-7"><a href="operator_member_access.html#Standard_library"><span class="tocnumber">2</span> <span class="toctext">Standard library</span></a></li>
<li class="toclevel-1 tocsection-8"><a href="operator_member_access.html#See_also"><span class="tocnumber">3</span> <span class="toctext">See also</span></a></li>
</ul>
</td></tr></table>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Explanation">edit</a>]</span> <span class="mw-headline" id="Explanation">Explanation</span>
</h3>
<p><i>array subscript</i> operator provides access to the elements in the internal array
</p>
<p><i>indirection</i>, <i>member of pointer</i> and <i>pointer to member of pointer</i> operators provide pointer semantics for any object. 
</p>
<p><i>member of pointer</i> and <i>pointer to member of pointer</i> operators return a pointer to the actual object which will be used for member access.
</p>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Built-in subscript operator">edit</a>]</span> <span class="mw-headline" id="Built-in_subscript_operator">Built-in subscript operator</span>
</h4>
<p>For every object type <code>T</code> (possibly cv-qualified), the following function signature participates in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="br0">[</span><span class="br0">]</span><span class="br0">(</span>T<span class="sy2">*</span>, <a href="../types/ptrdiff_t.html"><span class="kw101">std::<span class="me2">ptrdiff_t</span></span></a><span class="br0">)</span><span class="sy4">;</span></span></div>
</td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="br0">[</span><span class="br0">]</span><span class="br0">(</span><a href="../types/ptrdiff_t.html"><span class="kw101">std::<span class="me2">ptrdiff_t</span></span></a>, T<span class="sy2">*</span><span class="br0">)</span><span class="sy4">;</span></span></div>
</td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep">
<td></td>
<td></td>
<td></td>
</tr>
</tbody></table>
<p>The non-pointer operand may be any expression of integral or unscoped enumeration type, it is <a href="implicit_cast.html" title="cpp/language/implicit cast">implicitly converted</a> to <span class="t-lc"><a href="../types/ptrdiff_t.html" title="cpp/types/ptrdiff t">std::ptrdiff_t</a></span>. The expression <span class="t-c"><span class="mw-geshi cpp source-cpp">A<span class="br0">[</span>B<span class="br0">]</span></span></span> is exactly identical to the expression <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">*</span><span class="br0">(</span>A<span class="sy2">+</span>B<span class="br0">)</span></span></span>, that is, the pointer operand (which may be a result of array-to-pointer conversion, and which must point to an element of some array or one past the end) is adjusted to point at another element of the same array, following the rules of <a href="operator_arithmetic.html" title="cpp/language/operator arithmetic">pointer arithmetics</a>, and is then dereferenced.
</p>
<p>When applied to an array, the subscript expression is an lvalue if the array is an lvalue, and xvalue if it isn't. When applied to a pointer, the subscript expression is always lvalue.
</p>
<p>The type <code>T</code> is not allowed to be an <a href="incomplete_type.html" title="cpp/language/incomplete type" class="mw-redirect">incomplete type</a>, even if the size or internal structure of <code>T</code> is never used, as in <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span>x<span class="br0">[</span><span class="nu0">0</span><span class="br0">]</span></span></span>.
</p>
<div class="t-example">
<div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> a<span class="br0">[</span><span class="nu0">4</span><span class="br0">]</span> <span class="sy1">=</span> <span class="br0">{</span><span class="nu0">1</span>,<span class="nu0">2</span>,<span class="nu0">3</span>,<span class="nu0">4</span><span class="br0">}</span><span class="sy4">;</span>
    <span class="kw4">int</span><span class="sy2">*</span> p <span class="sy1">=</span> <span class="sy3">&amp;</span>a<span class="br0">[</span><span class="nu0">2</span><span class="br0">]</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1447">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> p<span class="br0">[</span><span class="nu0">1</span><span class="br0">]</span> <span class="sy1">&lt;&lt;</span> p<span class="br0">[</span><span class="sy2">-</span><span class="nu0">1</span><span class="br0">]</span> <span class="sy1">&lt;&lt;</span> <span class="nu0">1</span><span class="br0">[</span>p<span class="br0">]</span> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span><span class="sy2">-</span><span class="nu0">1</span><span class="br0">)</span><span class="br0">[</span>p<span class="br0">]</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">4242</pre></div></div> 
</div>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Built-in indirection operator">edit</a>]</span> <span class="mw-headline" id="Built-in_indirection_operator">Built-in indirection operator</span>
</h4>
<p>For every type <code>T</code> that is either object type (possibly cv-qualified) or function type (not const- or ref-qualified), the following function signature participates in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="sy2">*</span><span class="br0">(</span>T<span class="sy2">*</span><span class="br0">)</span><span class="sy4">;</span></span></div>
</td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep">
<td></td>
<td></td>
<td></td>
</tr>
</tbody></table>
<p>The operand of the built-in indirection operator is a pointer to object or function, and the result is the lvalue that the pointer is pointing at. Note that a pointer to incomplete type can be dereferenced, e.g. when initializing a reference.
</p>
<div class="t-example">
<div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
<span class="kw4">int</span> f<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> <span class="nu0">42</span><span class="sy4">;</span> <span class="br0">}</span>
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> n <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <span class="kw4">int</span><span class="sy2">*</span> pn <span class="sy1">=</span> <span class="sy3">&amp;</span>n<span class="sy4">;</span>
 
    <span class="kw4">int</span><span class="sy3">&amp;</span> r <span class="sy1">=</span> <span class="sy2">*</span>pn<span class="sy4">;</span>  <span class="co1">// lvalue can be bound to a reference</span>
    <span class="kw4">int</span> m <span class="sy1">=</span> <span class="sy2">*</span>pn<span class="sy4">;</span>   <span class="co1">// indirection + lvalue-to-rvalue conversion</span>
 
    <span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span>fp<span class="br0">)</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>f<span class="sy4">;</span>
    <span class="kw4">int</span> <span class="br0">(</span><span class="sy3">&amp;</span>fr<span class="br0">)</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy2">*</span>fp<span class="sy4">;</span> <span class="co1">// function lvalue can be bound to a reference </span>
<span class="br0">}</span></pre></div></div>
<p><br> 
</p>
</div>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Built-in address-of operator">edit</a>]</span> <span class="mw-headline" id="Built-in_address-of_operator">Built-in address-of operator</span>
</h4>
<p>The operand of the built-in <code>operator&amp;</code> is either an lvalue expression of any type or the qualified name of a non-static member function/object in some class. This operator does not participate in overload resolution. If there are no <a href="overload_resolution.html#Viable_functions" title="cpp/language/overload resolution">viable functions</a>, special rules are used: 
</p>
<p>If the operand is an lvalue expression of some type <code>T</code>, <code>operator&amp;</code> creates and returns a prvalue of type <code>T*</code>, with the same cv qualification, that is pointing at the object designated by the operand. If the operand has incomplete type, the pointer can be formed, but if that incomplete type happens to be a class that defines its own <code>operator&amp;</code>, <span class="t-rev-inl t-until-cxx14"><span>the behavior is undefined</span> <span><span class="t-mark-rev t-until-cxx14">(until C++14)</span></span></span> <span class="t-rev-inl t-since-cxx14"><span>it is unspecified whether the built-in or the overload is used</span> <span><span class="t-mark-rev t-since-cxx14">(since C++14)</span></span></span>. For the operands of type with user-defined <code>operator&amp;</code>, <span class="t-lc"><a href="../memory/addressof.html" title="cpp/memory/addressof">std::addressof</a></span> may be used to obtain the true pointer.
</p>
<p>If the operand is the name of an overloaded function, the address may be taken only if the overload can be resolved due to context. See <a href="overloaded_address.html" title="cpp/language/overloaded address">Address of an overloaded function</a> for details.
</p>
<p>If the operand is a qualified name of a non-static member, e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span>Class<span class="sy4">::</span><span class="me2">member</span></span></span>, the result is a prvalue pointer to member function or pointer to member object of type <code>T</code> in class <code>C</code>. Note that neither <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span>member</span></span> nor <span class="t-c"><span class="mw-geshi cpp source-cpp">Class<span class="sy4">::</span><span class="me2">member</span></span></span> nor even <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span><span class="br0">(</span>Class<span class="sy4">::</span><span class="me2">member</span><span class="br0">)</span></span></span> may be used to initialize a pointer to member.
</p>
<div class="t-example">
<div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
<span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">double</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
<span class="kw1">struct</span> A <span class="br0">{</span> <span class="kw4">int</span> i<span class="sy4">;</span> <span class="br0">}</span><span class="sy4">;</span>
<span class="kw1">struct</span> B <span class="br0">{</span> <span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="br0">}</span><span class="sy4">;</span>
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> n <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <span class="kw4">int</span><span class="sy2">*</span> pn <span class="sy1">=</span> <span class="sy3">&amp;</span>n<span class="sy4">;</span> <span class="co1">// pointer</span>
    <span class="kw4">int</span> A<span class="sy4">::</span><span class="sy2">*</span> mp <span class="sy1">=</span> <span class="sy3">&amp;</span>A<span class="sy4">::</span><span class="me2">i</span><span class="sy4">;</span>  <span class="co1">// pointer to member object</span>
    <span class="kw4">void</span> <span class="br0">(</span>B<span class="sy4">::</span><span class="sy2">*</span>mpf<span class="br0">)</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>B<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// pointer to member function</span>
 
<span class="co1">//    auto pf2 = &amp;f; // error: ambiguous overloaded function type</span>
    <span class="kw4">void</span> <span class="br0">(</span><span class="sy2">*</span>pf<span class="br0">)</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>f<span class="sy4">;</span> <span class="co1">// overload resolution due to initialization</span>
    <span class="kw4">auto</span> pf2 <span class="sy1">=</span> <span class="kw1">static_cast</span><span class="sy1">&lt;</span><span class="kw4">void</span><span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy1">&gt;</span><span class="br0">(</span><span class="sy3">&amp;</span>f<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// overload resolution due to cast</span>
<span class="br0">}</span></pre></div></div>
<p><br> 
</p>
</div>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Built-in member access operators">edit</a>]</span> <span class="mw-headline" id="Built-in_member_access_operators">Built-in member access operators</span>
</h4>
<p>The left operand of the built-in <code>operator.</code> and <code>operator-&gt;</code> is an expression of complete scalar type <code>T</code> (for <code>operator.</code>) or pointer to complete scalar type <code>T*</code> (for <code>operator-&gt;</code>), which is evaluated before the operator can be called. The right operand is the name of a member object or member function of <code>T</code> or of one of <code>T</code>'s base classes, e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="me1">member</span></span></span>, optionally <a href="name.html#Qualified_identifiers" title="cpp/language/identifiers">qualified</a>, e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="me1">name</span><span class="sy4">::</span><span class="me2">member</span></span></span>, optionally using <a href="dependent_name.html" title="cpp/language/dependent name">template disambiguator</a>, e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="kw1">template</span> member</span></span>.
</p>
<p>The expression <span class="t-c"><span class="mw-geshi cpp source-cpp">A<span class="sy2">-</span><span class="sy1">&gt;</span>B</span></span> is exactly equivalent to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span><span class="sy2">*</span>A<span class="br0">)</span>.<span class="me1">B</span></span></span> for builtin types. If a user-defined <code>operator-&gt;</code> is provided, <code>operator-&gt;</code> is called again on the value that it returns, recursively, until the <code>operator-&gt;</code> is reached that returns a plain pointer. After that, builtin semantics are applied to that pointer.
</p>
<p>In the expression <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="me1">B</span></span></span>,
</p>
<div class="t-li1">
<span class="t-li">1)</span> if <code>B</code> is a <a href="static.html" title="cpp/language/static">static data member</a> of type <code>T</code>, the result is an <a href="value_category.html" title="cpp/language/value category">lvalue</a> <code>T</code> designating that static data member.</div>
<div class="t-li1">
<span class="t-li">2)</span> if <code>B</code> is a <a href="data_members.html" title="cpp/language/data members">non-static data member</a> of type <code>T</code>, the result is an lvalue of type <code>T</code> if <code>B</code> has type <span class="t-c"><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span></span></span> or <span class="t-c"><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;&amp;</span></span></span>, otherwise the result is an lvalue if <code>expr</code> is an lvalue, or the result is a xvalue if <code>expr</code> is an rvalue. If <code>B</code> is not declared to be a <i>mutable</i> member, the <a href="cv.html" title="cpp/language/cv">cv-qualification</a> of the result is the union of cv-qualifications of <code>expr</code> and <code>B</code>. If <code>B</code> is mutable, the cv-qualification of the result is the union of volatile-qualifications.</div>
<div class="t-li1">
<span class="t-li">3)</span> if <code>B</code> is a static member function, the result is an lvalue designating the static memeber function. Essentially, <code>expr</code> is evaluated and discarded in this case.</div>
<div class="t-li1">
<span class="t-li">4)</span> if <code>B</code> is a <a href="member_functions.html" title="cpp/language/member functions">non-static member function</a> including a <a href="destructor.html" title="cpp/language/destructor">destructor</a>, the result is a special kind of prvalue that can only be used as the left-hand operand in a function-call expression, and for no other purpose.</div>
<div class="t-li1">
<span class="t-li">5)</span> if <code>B</code> is a member enumeration, the result is a prvalue of the enum type.</div>
<div class="t-li1">
<span class="t-li">6)</span> if <code>B</code> is a nested type, the program is ill-formed (won't compile)</div>
<div class="t-li1">
<span class="t-li">7)</span> if <code>expr</code> has non-class scalar type and B is a <code><b>~</b></code> followed by the <a href="incomplete_type.html#Type_naming" title="cpp/language/type">type name</a> or <a href="decltype.html" title="cpp/language/decltype">decltype specifier</a> designating the same type (minus cv-qualifications), optionally <a href="name.html#Qualified_identifiers" title="cpp/language/identifiers">qualified</a>, then the result is a special kind of prvalue that can only be used as the left-hand operand in a function-call expression, and for no other purpose. The function call is called <i>pseudo destructor call</i>, it takes no arguments, returns void, and performs no action other than initial evaluation of expr. <br>This is the only case where the left operand of <code>operator.</code> has non-class type. Allowing pseudo destructor call makes it possible to write code without having to know if a destructor exists for a given type.</div>
<div class="t-example">
<div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw1">struct</span> P <span class="br0">{</span>
    <span class="kw1">template</span><span class="sy1">&lt;</span><span class="kw1">typename</span> T<span class="sy1">&gt;</span>
    <span class="kw4">static</span> T<span class="sy2">*</span> ptr<span class="br0">(</span><span class="br0">)</span> <span class="kw1">noexcept</span> <span class="br0">{</span><span class="kw1">return</span> new T<span class="sy4">;</span><span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
<span class="kw1">template</span><span class="sy1">&lt;</span><span class="kw1">typename</span> T<span class="sy1">&gt;</span>
<span class="kw1">struct</span> A <span class="br0">{</span>
    <span class="kw1">class</span> B <span class="br0">{</span><span class="br0">}</span><span class="sy4">;</span>
    <span class="kw2">enum</span> E <span class="br0">{</span>RED <span class="sy1">=</span> <span class="nu0">1</span>, BLUE <span class="sy1">=</span> <span class="nu0">2</span><span class="br0">}</span><span class="sy4">;</span>
    <span class="kw4">int</span> n<span class="sy4">;</span>
    <span class="kw4">static</span> <span class="kw4">int</span> sn<span class="sy4">;</span>
    <span class="kw4">int</span> f<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> <span class="nu0">10</span><span class="sy2">+</span>n<span class="sy4">;</span> <span class="br0">}</span>
    <span class="kw4">static</span> <span class="kw4">int</span> fs<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> <span class="nu0">4</span><span class="sy4">;</span> <span class="br0">}</span>
    A<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span> <span class="sy4">:</span> n<span class="br0">(</span>n<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
 
    <span class="co1">// keyword template needed to refer to a dependent template member</span>
    <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
        <span class="kw1">typedef</span> <span class="kw4">int</span> U<span class="sy4">;</span>
        <span class="kw4">int</span><span class="sy2">*</span> p <span class="sy1">=</span> T<span class="br0">(</span><span class="br0">)</span>.<span class="kw1">template</span> ptr<span class="sy1">&lt;</span>U<span class="sy1">&gt;</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
        p<span class="sy2">-</span><span class="sy1">&gt;</span>~U<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// U is int, this calls int's pseudo destructor</span>
        delete p<span class="sy4">;</span>
    <span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
<span class="kw1">template</span><span class="sy1">&lt;&gt;</span> <span class="kw4">int</span> A<span class="sy1">&lt;</span>P<span class="sy1">&gt;</span><span class="sy4">::</span><span class="me2">sn</span> <span class="sy1">=</span> <span class="nu0">2</span><span class="sy4">;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    A<span class="sy1">&lt;</span>P<span class="sy1">&gt;</span> a<span class="br0">(</span><span class="nu0">1</span><span class="br0">)</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1447">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> a.<span class="me1">n</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span>
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">sn</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span> <span class="co1">// &lt;&lt; A::sn also works</span>
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">f</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span> 
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">fs</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span> <span class="co1">// A::fs() also works</span>
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">RED</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span>  <span class="co1">// enumerator</span>
<span class="co1">//            &lt;&lt; a.B  // nested type not allowed</span>
              <span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">1 2 11 4 1</pre></div></div> 
</div>
<h4>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Built-in pointer-to-member access operators">edit</a>]</span> <span class="mw-headline" id="Built-in_pointer-to-member_access_operators">Built-in pointer-to-member access operators</span>
</h4>
<p>The right operand of both <code>operator.*</code> and <code>operator-&gt;*</code> is an expression of type pointer to member in class <code>T</code>. For <code>operator.*</code>, the left operand is an expression of class type <code>T</code>, or of some derived class in which <code>T</code> is unambiguous accessible base. For <code>operator-&gt;*</code>, the left operand is a pointer to <code>T</code> or to its base. 
</p>
<p>For every combination of types <code>B</code>, <code>D</code>, <code>T</code>, where <code>D</code> is either the same as <code>B</code> or a class derived from <code>B</code>, and <code>T</code> is either object or function type, the following function signature participates in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span><span class="br0">(</span>B<span class="sy2">*</span>, T D<span class="sy4">::</span><span class="sy2">*</span><span class="br0">)</span><span class="sy4">;</span></span></div>
</td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep">
<td></td>
<td></td>
<td></td>
</tr>
</tbody></table>
<p>where both operands may be cv-qualified, in which case the return type's cv-qualification is the union of the cv-qualification of the operands.
</p>
<p>The expression <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>E2</span></span> is exactly equivalent to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span><span class="sy2">*</span>E1<span class="br0">)</span>.<span class="sy2">*</span>E2</span></span> for built-in types.
</p>
<p>For the expression <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="sy2">*</span>ptr</span></span>, 
</p>
<div class="t-li1">
<span class="t-li">1)</span> If the <a href="incomplete_type.html#Dynamic_type" title="cpp/language/type">dynamic type</a> of <code>expr</code> does not contain the member to which <code>ptr</code> refers, the behavior is undefined</div>
<div class="t-li1">
<span class="t-li">2)</span> cv-qualification rules are the same as for member access operator, with one additional rule: a pointer to member that refers to a mutable member cannot be used to modify that member in a const object.</div>
<div class="t-li1">
<span class="t-li">4)</span> If <code>expr</code> is rvalue and <code>ptr</code> points to a member function with &amp; ref-qualifier, the program is ill-formed</div>
<div class="t-li1">
<span class="t-li">5)</span> If <code>expr</code> is lvalue and <code>ptr</code> points to a member function with &amp;&amp; ref-qualifier, the program is ill-formed</div>
<div class="t-li1">
<span class="t-li">6)</span> The result of <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="sy2">*</span>ptr</span></span> where <code>ptr</code> is a pointer to data member has the same value category as <code>expr</code>.</div>
<div class="t-li1">
<span class="t-li">7)</span> The result of <span class="t-c"><span class="mw-geshi cpp source-cpp">expr.<span class="sy2">*</span>ptr</span></span> where <code>ptr</code> is a pointer to member function is a special kind of prvalue that may only be used as the left-hand argument of a function call expression and for no other purpose.</div>
<div class="t-li1">
<span class="t-li">8)</span> If <code>ptr</code> is a null pointer value, the behavior is undefined</div>
<div class="t-example">
<div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
<span class="kw1">struct</span> S
<span class="br0">{</span>
    mutable <span class="kw4">int</span> mi<span class="sy4">;</span>
    <span class="kw4">int</span> f<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> mi<span class="sy2">+</span>n<span class="sy4">;</span> <span class="br0">}</span>
    S<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span> <span class="sy4">:</span> mi<span class="br0">(</span>n<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
<span class="kw1">struct</span> D <span class="sy4">:</span> <span class="kw1">public</span> S <span class="br0">{</span>
        D<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span> <span class="sy4">:</span> S<span class="br0">(</span>n<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> S<span class="sy4">::</span><span class="sy2">*</span> pmi <span class="sy1">=</span> <span class="sy3">&amp;</span>S<span class="sy4">::</span><span class="me2">mi</span><span class="sy4">;</span>
    <span class="kw4">int</span> <span class="br0">(</span>S<span class="sy4">::</span><span class="sy2">*</span>mpf<span class="br0">)</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>S<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span>
 
    <span class="kw4">const</span> S s<span class="br0">(</span><span class="nu0">7</span><span class="br0">)</span><span class="sy4">;</span>
<span class="co1">//    s.*pmi = 10; // cannot modify through mutable</span>
    <a href="../io/cout.html"><span class="kw1447">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> s.<span class="sy2">*</span>pmi <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
 
    D d<span class="br0">(</span><span class="nu0">7</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// base pointers work with derived object</span>
    D<span class="sy2">*</span> dp <span class="sy1">=</span> <span class="sy3">&amp;</span>d<span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1447">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>d.<span class="sy2">*</span>mpf<span class="br0">)</span><span class="br0">(</span><span class="nu0">7</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span>
              <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>dp<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>mpf<span class="br0">)</span><span class="br0">(</span><span class="nu0">8</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">7
14 15</pre></div></div> 
</div>
<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: Standard library">edit</a>]</span> <span class="mw-headline" id="Standard_library">Standard library</span>
</h3>
<p>Subscript operator is overloaded by many standard container classes
</p>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../utility/bitset/operator_at.html" title="cpp/utility/bitset/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   accesses specific bit <br> <span class="t-mark">(public member function of <code>std::bitset</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/unique_ptr/operator_at.html" title="cpp/memory/unique ptr/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   provides indexed access to the managed array  <br> <span class="t-mark">(public member function of <code>std::unique_ptr</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../string/basic_string/operator_at.html" title="cpp/string/basic string/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>    access specified character <br> <span class="t-mark">(public member function of <code>std::basic_string</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/array/operator_at.html" title="cpp/container/array/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access specified element  <br> <span class="t-mark">(public member function of <code>std::array</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/deque/operator_at.html" title="cpp/container/deque/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access specified element  <br> <span class="t-mark">(public member function of <code>std::deque</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/vector/operator_at.html" title="cpp/container/vector/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access specified element  <br> <span class="t-mark">(public member function of <code>std::vector</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/map/operator_at.html" title="cpp/container/map/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access specified element  <br> <span class="t-mark">(public member function of <code>std::map</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/unordered_map/operator_at.html" title="cpp/container/unordered map/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access specified element  <br> <span class="t-mark">(public member function of <code>std::unordered_map</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/reverse_iterator/operator_at.html" title="cpp/iterator/reverse iterator/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   accesses an element by index <br> <span class="t-mark">(public member function of <code>std::reverse_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/move_iterator/operator_at.html" title="cpp/iterator/move iterator/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>    accesses an element by index <br> <span class="t-mark">(public member function of <code>std::move_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_at.html" title="cpp/numeric/valarray/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   get/set valarray element, slice, or mask <br> <span class="t-mark">(public member function of <code>std::valarray</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../regex/match_results/operator_at.html" title="cpp/regex/match results/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   returns specified sub-match <br> <span class="t-mark">(public member function of <code>std::match_results</code>)</span> 
</td>
</tr>
</table>
<p>The indirection and member access operators are overloaded by many iterators and smart pointer classes
</p>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/unique_ptr/operator%2A.html" title="cpp/memory/unique ptr/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   dereferences pointer to the managed object  <br> <span class="t-mark">(public member function of <code>std::unique_ptr</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/shared_ptr/operator%2A.html" title="cpp/memory/shared ptr/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   dereferences pointer to the managed object  <br> <span class="t-mark">(public member function of <code>std::shared_ptr</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/auto_ptr/operator%2A.html" title="cpp/memory/auto ptr/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses the managed object <br> <span class="t-mark">(public member function of <code>std::auto_ptr</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/raw_storage_iterator/operator%2A.html" title="cpp/memory/raw storage iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   dereferences the iterator <br> <span class="t-mark">(public member function of <code>std::raw_storage_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/reverse_iterator/operator%2A.html" title="cpp/iterator/reverse iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   dereferences the decremented underlying iterator <br> <span class="t-mark">(public member function of <code>std::reverse_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/back_insert_iterator/operator%2A.html" title="cpp/iterator/back insert iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::back_insert_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/front_insert_iterator/operator%2A.html" title="cpp/iterator/front insert iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::front_insert_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/insert_iterator/operator%2A.html" title="cpp/iterator/insert iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::insert_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/move_iterator/operator%2A.html" title="cpp/iterator/move iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses the pointed-to element <br> <span class="t-mark">(public member function of <code>std::move_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/istream_iterator/operator%2A.html" title="cpp/iterator/istream iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   returns the current element <br> <span class="t-mark">(public member function of <code>std::istream_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/ostream_iterator/operator%2A.html" title="cpp/iterator/ostream iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::ostream_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div">
<div><a href="../iterator/istreambuf_iterator/operator%2A.html" title="cpp/iterator/istreambuf iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div>
<div><span class="t-lines"><span></span><span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span></div>
</div>
</td>
<td>   obtains a copy of the current character<br>accesses a member of the current character, if <code>CharT</code> has members  <br> <span class="t-mark">(public member function of <code>std::istreambuf_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/ostreambuf_iterator/operator%2A.html" title="cpp/iterator/ostreambuf iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::ostreambuf_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../regex/regex_iterator/operator%2A.html" title="cpp/regex/regex iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses the current match <br> <span class="t-mark">(public member function of <code>std::regex_iterator</code>)</span> 
</td>
</tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../regex/regex_token_iterator/operator%2A.html" title="cpp/regex/regex token iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses current submatch <br> <span class="t-mark">(public member function of <code>std::regex_token_iterator</code>)</span> 
</td>
</tr>

No standard library classes overload <code>operator&amp;</code> or <code>operator-&gt;*</code>. The best known example of overloaded <code>operator&amp;</code> is the Microsoft COM class <a rel="nofollow" class="external text" href="http%3A//msdn.microsoft.com/en-us/library/31k6d0k7%28v%3Dvs.100%29.aspx">CComPtr</a>. <code>operator-&gt;*</code> is sometimes overloaded by third-party <a rel="nofollow" class="external text" href="http%3A//www.aristeia.com/Papers/DDJ_Oct_1999.pdf">custom smart pointers</a>.

<h3>
<span class="editsection">[<a href="http%3A//en.cppreference.com/mwiki/index.php" title="Edit section: See also">edit</a>]</span> <span class="mw-headline" id="See_also">See also</span>
</h3>
<p><a href="operator_precedence.html" title="cpp/language/operator precedence"> Operator precedence</a>
</p>
<p><a href="operators.html" title="cpp/language/operators"> Operator overloading</a>
</p>
<table class="wikitable">

<tr style="text-align:center">
<th colspan="7"> Common operators
</th>
</tr>
<tr style="text-align:center">
<td> <a href="operator_assignment.html" title="cpp/language/operator assignment"> assignment</a>
</td>
<td> <a href="operator_incdec.html" title="cpp/language/operator incdec"> increment<br>decrement</a>
</td>
<td> <a href="operator_arithmetic.html" title="cpp/language/operator arithmetic"> arithmetic</a>
</td>
<td> <a href="operator_logical.html" title="cpp/language/operator logical"> logical</a>
</td>
<td> <a href="operator_comparison.html" title="cpp/language/operator comparison"> comparison</a>
</td>
<td> <strong class="selflink"> member<br>access</strong>
</td>
<td> <a href="operator_other.html" title="cpp/language/operator other"> other</a>
</td>
</tr>
<tr style="text-align:center">
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">=</span> b<br>
a <span class="sy2">+</span><span class="sy1">=</span> b<br>
a <span class="sy2">-</span><span class="sy1">=</span> b<br>
a <span class="sy2">*</span><span class="sy1">=</span> b<br>
a <span class="sy2">/</span><span class="sy1">=</span> b<br>
a <span class="sy2">%</span><span class="sy1">=</span> b<br>
a <span class="sy3">&amp;</span><span class="sy1">=</span> b<br>
a <span class="sy3">|</span><span class="sy1">=</span> b<br>
a <span class="sy3">^</span><span class="sy1">=</span> b<br>
a <span class="sy1">&lt;&lt;=</span> b<br>
a <span class="sy1">&gt;&gt;=</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">++</span>a<br>
<span class="sy2">--</span>a<br>
a<span class="sy2">++</span><br>
a<span class="sy2">--</span></span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">+</span>a<br>
<span class="sy2">-</span>a<br>
a <span class="sy2">+</span> b<br>
a <span class="sy2">-</span> b<br>
a <span class="sy2">*</span> b<br>
a <span class="sy2">/</span> b<br>
a <span class="sy2">%</span> b<br>
~a<br>
a <span class="sy3">&amp;</span> b<br>
a <span class="sy3">|</span> b<br>
a <span class="sy3">^</span> b<br>
a <span class="sy1">&lt;&lt;</span> b<br>
a <span class="sy1">&gt;&gt;</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">!</span>a<br>
a <span class="sy3">&amp;&amp;</span> b<br>
a <span class="sy3">||</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">==</span> b<br>
a <span class="sy3">!</span><span class="sy1">=</span> b<br>
a <span class="sy1">&lt;</span> b<br>
a <span class="sy1">&gt;</span> b<br>
a <span class="sy1">&lt;=</span> b<br>
a <span class="sy1">&gt;=</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span>b<span class="br0">]</span><br>
<span class="sy2">*</span>a<br>
<span class="sy3">&amp;</span>a<br>
a<span class="sy2">-</span><span class="sy1">&gt;</span>b<br>
a.<span class="me1">b</span><br>
a<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>b<br>
a.<span class="sy2">*</span>b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">(</span>...<span class="br0">)</span><br>
a, b<br>
<span class="br0">(</span>type<span class="br0">)</span> a<br>
<span class="sy4">?</span> <span class="sy4">:</span></span></span>
</p>
</td>
</tr>
<tr>
<th colspan="7"> Special operators
</th>
</tr>
<tr>
<td colspan="7">
<p><a href="static_cast.html" title="cpp/language/static cast"><tt>static_cast</tt></a> converts one type to another compatible type <br>
<a href="dynamic_cast.html" title="cpp/language/dynamic cast"><tt>dynamic_cast</tt></a> converts virtual base class to derived class<br>
<a href="const_cast.html" title="cpp/language/const cast"><tt>const_cast</tt></a> converts type to compatible type with different <a href="cv.html" title="cpp/language/cv">cv</a> qualifiers<br>
<a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><tt>reinterpret_cast</tt></a> converts type to incompatible type<br>
<a href="../memory/new/operator_new.html" title="cpp/memory/new/operator new"><tt>new</tt></a> allocates memory<br>
<a href="../memory/new/operator_delete.html" title="cpp/memory/new/operator delete"><tt>delete</tt></a> deallocates memory<br>
<a href="sizeof.html" title="cpp/language/sizeof"><tt>sizeof</tt></a> queries the size of a type<br>
<a href="sizeof....html" title="cpp/language/sizeof..."><tt>sizeof...</tt></a> queries the size of a <a href="parameter_pack.html" title="cpp/language/parameter pack">parameter pack</a> <span class="t-mark-rev t-since-cxx11">(since C++11)</span><br>
<a href="typeid.html" title="cpp/language/typeid"><tt>typeid</tt></a> queries the type information of a type<br>
<a href="noexcept.html" title="cpp/language/noexcept"><tt>noexcept</tt></a> checks if an expression can throw an exception <span class="t-mark-rev t-since-cxx11">(since C++11)</span><br>
<a href="alignof.html" title="cpp/language/alignof"><tt>alignof</tt></a> queries alignment requirements of a type <span class="t-mark-rev t-since-cxx11">(since C++11)</span>
</p>
</td>
</tr>
</table>
</table>

<!-- 
NewPP limit report
Preprocessor visited node count: 9030/1000000
Preprocessor generated node count: 12172/1000000
Post‐expand include size: 205507/2097152 bytes
Template argument size: 49547/2097152 bytes
Highest expansion depth: 32/40
Expensive parser function count: 0/100
-->

<!-- Saved in parser cache with key mwiki1-mwiki_en_:pcache:idhash:707-0!*!0!!en!*!* and timestamp 20150523202201 -->
</div>                    <!-- /bodycontent -->
                                        <!-- printfooter -->
                    <div class="printfooter">
                    Retrieved from "<a href="http%3A//en.cppreference.com/mwiki/index.php">http://en.cppreference.com/mwiki/index.php?title=cpp/language/operator_member_access&amp;oldid=76806</a>"                    </div>
                    <!-- /printfooter -->
                                                            <!-- catlinks -->
                    <div id="catlinks" class="catlinks catlinks-allhidden"></div>                    <!-- /catlinks -->
                                                            <div class="visualClear"></div>
                    <!-- debughtml -->
                                        <!-- /debughtml -->
                </div>
                <!-- /bodyContent -->
            </div>
        </div>
        <!-- /content -->
        <!-- footer -->
        
        <!-- /footer -->
        <script>if(window.mw){
mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"});
}</script>
<script src="../../../common/skin_scripts.js"></script>
<script>if(window.mw){
mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler"], null, true);
}</script>
<script src="../../../common/site_scripts.js"></script>

<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2828341-1']);
_gaq.push(['_setDomainName', 'cppreference.com']);
_gaq.push(['_trackPageview']);
</script><!-- Served in 6.218 secs. -->
	</body>
<!-- Cached 20150523202201 -->
</html>
